package com.monitor.service;

import com.alibaba.fastjson.JSONObject;
import com.monitor.filter.ContentFilter;
import com.monitor.filter.UrlFilter;
import com.monitor.filter.KeywordFilter;
import com.monitor.network.HttpClient;
import com.monitor.util.BrowserUrlMonitor;
import javafx.application.Platform;
import javafx.scene.control.Alert;
import javafx.scene.control.ButtonType;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 浏览器监控服务类
 * 负责监控浏览器访问，进行网站过滤和关键字过滤
 */
public class BrowserMonitorService {
    private static BrowserMonitorService instance;
    private final UrlFilter urlFilter;
    private final KeywordFilter keywordFilter;
    private final ScheduledExecutorService scheduler;
    private final HttpClient httpClient;
    
    // 配置信息
    private boolean websiteFilterEnabled = false;
    private boolean keywordFilterEnabled = true; // 默认启用关键字过滤
    private List<String> websiteBlacklist;
    private List<String> keywordBlacklist;
    
    // 后台API配置
    private static final String API_BASE_URL = "http://localhost:8080";
    private static final String NETWORK_LOG_API = "/h5/log";
    
    private BrowserMonitorService() {
        this.urlFilter = new UrlFilter();
        this.keywordFilter = new KeywordFilter();
        this.scheduler = Executors.newScheduledThreadPool(2);
        this.httpClient = new HttpClient();
        
        // 初始化默认关键字黑名单
        initDefaultKeywords();
        
        // 启动浏览器监控
        startBrowserMonitoring();
    }
    
    private BrowserMonitorService(List<String> externalKeywordBlacklist) {
        this.urlFilter = new UrlFilter();
        this.keywordFilter = new KeywordFilter(externalKeywordBlacklist);
        this.scheduler = Executors.newScheduledThreadPool(2);
        this.httpClient = new HttpClient();
        
        // 如果外部提供了关键词列表，使用外部列表；否则使用默认列表
        if (externalKeywordBlacklist != null && !externalKeywordBlacklist.isEmpty()) {
            this.keywordBlacklist = new ArrayList<>(externalKeywordBlacklist);
        } else {
            initDefaultKeywords();
        }
        
        // 启动浏览器监控
        startBrowserMonitoring();
    }
    
    /**
     * 初始化默认关键字黑名单
     */
    private void initDefaultKeywords() {
        keywordBlacklist = new ArrayList<>();
        keywordBlacklist.add("关于测试");
        keywordBlacklist.add("测试关键字");
        keywordBlacklist.add("敏感内容");
        
        // 更新KeywordFilter的黑名单
        keywordFilter.updateBlacklist(keywordBlacklist);
    }
    
    public static synchronized BrowserMonitorService getInstance() {
        if (instance == null) {
            instance = new BrowserMonitorService();
        }
        return instance;
    }
    
    public static synchronized BrowserMonitorService getInstance(List<String> keywordBlacklist) {
        if (instance == null) {
            instance = new BrowserMonitorService(keywordBlacklist);
        }
        return instance;
    }
    
    /**
     * 更新网站过滤配置
     */
    public void updateWebsiteFilterConfig(boolean enabled, List<String> blacklist) {
        this.websiteFilterEnabled = enabled;
        this.websiteBlacklist = blacklist;
        
        // 更新UrlFilter的黑名单
        if (blacklist != null) {
            urlFilter.updateBlacklist(blacklist);
        }
    }
    
    /**
     * 更新关键字过滤配置
     */
    public void updateKeywordFilterConfig(boolean enabled, List<String> blacklist) {
        this.keywordFilterEnabled = enabled;
        this.keywordBlacklist = blacklist;
        
        // 更新KeywordFilter的黑名单
        if (blacklist != null) {
            keywordFilter.updateBlacklist(blacklist);
        }
    }
    
    /**
     * 启动浏览器监控
     */
    private void startBrowserMonitoring() {
        // 定期检查浏览器活动
        scheduler.scheduleAtFixedRate(this::checkBrowserActivity, 0, 10, TimeUnit.SECONDS);
    }
    
    /**
     * 检查浏览器活动
     */
    private void checkBrowserActivity() {
        try {
            System.out.println("=== 开始检查浏览器活动 ===");
            String currentUrl = BrowserUrlMonitor.getCurrentUrl();
            String pageContent = BrowserUrlMonitor.getCurrentPageContent();
            
            System.out.println("当前URL: " + currentUrl);
            System.out.println("页面内容: " + pageContent);
            
            if (currentUrl != null && !currentUrl.isEmpty()) {
                // 检查URL过滤
                checkAndFilterUrl(currentUrl);
                
                // 检查关键字过滤
                checkAndFilterKeywords(pageContent, currentUrl);
            } else {
                System.out.println("未获取到有效的URL");
            }
            System.out.println("=== 浏览器活动检查完成 ===");
        } catch (Exception e) {
            System.err.println("检查浏览器活动时发生错误: " + e.getMessage());
            e.printStackTrace();
        }
    }
    
    /**
     * 检查并过滤URL
     */
    private void checkAndFilterUrl(String url) {
        if (!websiteFilterEnabled) {
            return;
        }
        
        if (urlFilter.containsInappropriateContent(url)) {
            // 阻断访问
            blockAccess("网站访问被阻断", "访问的网站 " + url + " 在黑名单中，禁止访问！");
            
            // 上传日志
            uploadNetworkLog("0", url, "网站过滤：访问被阻断的网站 - " + url);
        }
    }
    
    /**
     * 检查并过滤关键字
     */
    private void checkAndFilterKeywords(String content, String url) {
        if (!keywordFilterEnabled) {
            System.out.println("关键字过滤已禁用");
            return;
        }
        
        System.out.println("正在检查页面内容: " + content);
        
        if (content != null && !content.trim().isEmpty()) {
            if (keywordFilter.containsInappropriateContent(content)) {
                System.out.println("*** 检测到敏感关键字，阻断访问 ***");
                System.out.println("触发内容: " + content);
                
                // 阻断访问
                blockAccess("关键字过滤", "页面内容包含敏感关键字，禁止访问！");
                
                // 上传日志
                uploadNetworkLog("1", url, "关键字过滤： " + url);
                
                // 显示警告信息
                showKeywordWarning(content);

                //关闭包含关键字的浏览器标签页面
                closeSpecificBrowserTab(url, content);
                System.out.println("已关闭包含敏感关键字的浏览器标签页: " + url);
            } else {
                // 上传日志
                uploadNetworkLog("0", url, "<访问网站>" + url);
                System.out.println("页面内容检查通过，未发现敏感关键字");
            }
        } else {
            System.out.println("页面内容为空，跳过关键字检查");
        }
    }
    
    /**
     * 关闭包含敏感内容的特定浏览器标签页
     */
    private void closeSpecificBrowserTab(String url, String content) {
        try {
            System.out.println("正在关闭包含敏感内容的浏览器标签页...");
            System.out.println("目标URL: " + url);
            System.out.println("敏感内容: " + content);
            
            // 获取当前浏览器URL，确认是否为目标页面
            String currentUrl = BrowserUrlMonitor.getCurrentUrl();
            
            if (currentUrl != null && currentUrl.contains(url)) {
                // 如果当前页面就是包含敏感内容的页面，直接关闭
                BrowserUrlMonitor.closeCurrentTab();
                System.out.println("已关闭当前标签页，URL匹配: " + currentUrl);
            } else {
                // 如果当前页面不是目标页面，尝试查找并关闭包含该URL的标签页
                boolean success = closeTabByUrl(url);
                if (success) {
                    System.out.println("已成功关闭包含敏感内容的标签页");
                } else {
                    System.out.println("未找到包含该URL的标签页，关闭当前活动标签页作为备选方案");
                    BrowserUrlMonitor.closeCurrentTab();
                }
            }
            
        } catch (Exception e) {
            System.err.println("关闭特定浏览器标签页失败: " + e.getMessage());
            // 备选方案：关闭当前标签页
            try {
                BrowserUrlMonitor.closeCurrentTab();
            } catch (Exception ex) {
                System.err.println("备选关闭方案也失败: " + ex.getMessage());
            }
        }
    }
    
    /**
     * 根据URL关闭特定的浏览器标签页
     */
    private boolean closeTabByUrl(String targetUrl) {
        try {
            // 这里实现根据URL查找并关闭特定标签页的逻辑
            // 由于浏览器API限制，目前采用简化实现：
            // 1. 检查当前活动窗口是否匹配目标URL
            // 2. 如果匹配则关闭，如果不匹配则返回false
            
            String currentUrl = BrowserUrlMonitor.getCurrentUrl();
            if (currentUrl != null && (currentUrl.equals(targetUrl) || currentUrl.contains(targetUrl))) {
                BrowserUrlMonitor.closeCurrentTab();
                return true;
            }
            
            // 未来可以扩展为遍历所有浏览器标签页的功能
            return false;
            
        } catch (Exception e) {
            System.err.println("根据URL关闭标签页失败: " + e.getMessage());
            return false;
        }
    }
    
    /**
     * 显示关键字警告
     */
    private void showKeywordWarning(String content) {
        // 这里可以显示一个警告对话框或通知
        System.out.println("=== 关键字过滤警告 ===");
        System.out.println("检测到敏感关键字: " + content);
        System.out.println("请注意您的浏览行为！");
        System.out.println("========================");
    }
    
    /**
     * 阻断访问并显示提示框
     */
    private void blockAccess(String title, String message) {
        Platform.runLater(() -> {
            Alert alert = new Alert(Alert.AlertType.WARNING);
            alert.setTitle(title);
            alert.setHeaderText("访问被阻断");
            alert.setContentText(message);
            alert.getButtonTypes().setAll(ButtonType.OK);
            alert.showAndWait();
        });
        
        // 这里可以添加更强制的阻断措施，比如关闭浏览器标签页
        // 由于技术限制，这里只显示警告
    }
    
    /**
     * 上传网络日志到后台
     */
    private void uploadNetworkLog(String logType, String url, String logDetail) {
        CompletableFuture.runAsync(() -> {
            try {
                JSONObject logData = new JSONObject();
                logData.put("deptId", 1L); // 默认部门ID
                logData.put("deviceId", 1L); // 默认设备ID
                logData.put("startTime", LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
                logData.put("endTime", LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
                logData.put("websiteType", "5"); // 其他类型
                logData.put("dataVolume", 0L);
                logData.put("logType", logType); // 0访问网站 1关键字过滤
                logData.put("logDetail", logDetail);
                logData.put("createId", 1L);
                logData.put("createName", "系统");
                logData.put("createTime", LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
                
                String response = httpClient.post(API_BASE_URL + NETWORK_LOG_API, logData.toJSONString());
                System.out.println("网络日志上传成功: " + response);
            } catch (Exception e) {
                System.err.println("网络日志上传失败: " + e.getMessage());
            }
        });
    }
    

    
    /**
     * 检查浏览器是否正在运行
     */
    public boolean isBrowserRunning() {
        return BrowserUrlMonitor.isBrowserRunning();
    }
    
    /**
     * 启动监控服务
     */
    public void startMonitoring() {
        System.out.println("浏览器监控服务正在启动...");
        // 启动浏览器监控已经在构造函数中调用了，这里可以添加额外的启动逻辑
        System.out.println("浏览器监控服务启动完成");
    }
    
    /**
     * 停止监控服务
     */
    public void shutdown() {
        if (scheduler != null && !scheduler.isShutdown()) {
            scheduler.shutdown();
        }
    }
}